Gradual Typing for Annotated Type Systems

Refinement type systems have been proposed by a number of researchers to sharpen the guarantees of existing type systems. Examples are systems that distinguish empty and non-empty lists by type, taint tracking and information flow control, dimension analysis, and many others. In each case, the type language is extended with annotations that either abstract semantic properties of values beyond the capabilities of the underlying type language (e.g., empty and non-empty lists) or they express extrinsic properties that are not locally checkable (e.g., taintedness, dimensions). Gradual typing emerged as an approach to combine static and dynamic typing in a single language. Recent work considered a number of variations on gradual typing that are not directly related to dynamic typing, like gradual information flow, gradual typestate, and gradual effect systems. Instead of considering entire types as static or dynamic, these systems focus on gradualizing type refinements. This proliferation of gradual systems begs the question if there is a common underlying structure. In this work, we give a partial answer by outlining a generic approach to “gradualize” existing annotated type systems that support annotations on base types. We illustrate the usefulness of gradual annotation typing with the example of gradual dimension annotations. Type systems with dimensions prevent the programmer to mix up measurements of different dimensions that are represented with a common numeric type. For illustration we consider an ML-like language with simple types where numbers carry a dimension annotation. The following function, calculating an estimated time to arrival, is well-typed in this language. fun eta (dist : float[m]) (vel:float[m/s]) : float[s] = dist / vel The annotated type float[u] represents an integer of dimension u where u ranges over the free abelian group generated by the SI base dimensions: m, s, kg, and so on. Each gain in safety costs flexibility. For example, a straightforward definition of the power function on meters fails to type-check in a system based on simple types. fun pow_m (x : float[m]) (y : int[1]) = if y == 0 then 1[S(1)] else x * pow_m x (y 1) The annotation S(1) indicates a statically checked dimensionless number.